{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "executionInfo": {
     "elapsed": 7103,
     "status": "ok",
     "timestamp": 1649955991305,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "rnRofK9F_TnT"
   },
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import rl_utils\n",
    "from tqdm import tqdm\n",
    "import imageio\n",
    "\n",
    "## 构造智能体 agent 的大脑，也就是输入状态，返回该状态下，选择每个动作的概率\n",
    "## 输入是状态的，也就是 (车子center-point的坐标，车子的速度，杆的竖直角度，杆的角速度)\n",
    "## 返回值应该是2 dim\n",
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(PolicyNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return F.softmax(self.fc2(x), dim=1)  ## 返回该状态下，选择的动作的概率\n",
    "\n",
    "## 构造智能体 agent 的大脑，也就是输入状态，返回该状态下，每个动作的动作价值\n",
    "## 输入是状态的，也就是 (车子center-point的坐标，车子的速度，杆的竖直角度，杆的角速度)\n",
    "## 返回值应该是2 dim\n",
    "class ValueNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim):\n",
    "        super(ValueNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return self.fc2(x)\n",
    "\n",
    "\n",
    "class PPO:\n",
    "    ''' PPO算法,采用截断方式 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, actor_lr, critic_lr,\n",
    "                 lmbda, epochs, eps, gamma, device):\n",
    "        self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device) ##  策略网络的\n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device) ##  价值网络\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(),\n",
    "                                                lr=actor_lr)     ##  函数配置优化器\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(),\n",
    "                                                 lr=critic_lr)   ##  价值函数配置优化器\n",
    "        self.gamma = gamma   ## 衰减因子的呢\n",
    "        self.lmbda = lmbda\n",
    "        self.epochs = epochs  # 一条序列的数据用来训练轮数\n",
    "        self.eps = eps  # PPO中截断范围的参数\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):            # 根据动作概率分布随机采样\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.actor(state)       ## 拿到该状态下，每个动作的选择概率\n",
    "        action_dist = torch.distributions.Categorical(probs)    ##   配置 好采样的概率\n",
    "        action = action_dist.sample()        ## 对该状态下，所有的动作采样，采样的概率是probs\n",
    "        return action.item()                 ## 返回依概率采样得到的动作\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        ## 拿到这条序列内的 状态、动作和奖励，下一个状态、是否完成的\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        ## 用下个状态求下一个状态的状态动作价值，然后间接求出当前状态的状态动作价值\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 - dones)\n",
    "        ## 间接求出的价值 - 直接求出的当前状态的状态动作价值，也就是 TD-error，或者是优势函数 A\n",
    "        td_delta = td_target - self.critic(states)\n",
    "        ##  算出优势函数，广义优势估计，也就是每一步优势的均值\n",
    "        advantage = rl_utils.compute_advantage(self.gamma, self.lmbda, td_delta.cpu()).to(self.device)\n",
    "        ## 选择的旧动作概率的log值，不反向传播求梯度，detach\n",
    "        old_log_probs = torch.log(self.actor(states).gather(1, actions)).detach()\n",
    "\n",
    "        for _ in range(self.epochs):\n",
    "            ## 选择的动作概率的log值，不反向传播求梯度，detach\n",
    "            log_probs = torch.log(self.actor(states).gather(1, actions))\n",
    "            ratio = torch.exp(log_probs - old_log_probs) ## 算重要性采样\n",
    "            surr1 = ratio * advantage  ## 重要性采样和优势估计相乘的\n",
    "            surr2 = torch.clamp(ratio, 1 - self.eps, 1 + self.eps) * advantage  # 截断\n",
    "            ## 算出来的重要性采样，求出两者间的最小值，然后加负号，也就是最大化目标函数，不加负号的话是最小化目标函数\n",
    "            actor_loss = torch.mean(-torch.min(surr1, surr2))  # PPO损失函数\n",
    "            ## 直接求出当前状态的状态动作价值，和 间接求出的价值，使用 MSE 来算损失函数的，td_target不反向传播求梯度，detach\n",
    "            critic_loss = torch.mean(F.mse_loss(self.critic(states), td_target.detach()))\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            self.critic_optimizer.zero_grad()   ## 价值网络的参数梯度置零的\n",
    "            actor_loss.backward()\n",
    "            critic_loss.backward()   ## 价值网络的损失loss反向传播梯度\n",
    "            self.actor_optimizer.step()\n",
    "            self.critic_optimizer.step()  # 更新价值函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 37845,
     "status": "ok",
     "timestamp": 1649956029144,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "-mccFiNn_TnV",
    "outputId": "48b888b5-d2a4-4505-e6cf-580efc7e782f"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|                                                                              | 0/50 [00:00<?, ?it/s]C:\\Users\\10696\\AppData\\Local\\Temp\\ipykernel_4820\\16392006.py:54: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ..\\torch\\csrc\\utils\\tensor_new.cpp:248.)\n",
      "  state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
      "Iteration 0: 100%|█████████████████████████████████████████| 50/50 [00:15<00:00,  3.24it/s, episode=50, return=294.800]\n",
      "Iteration 1: 100%|████████████████████████████████████████| 50/50 [00:45<00:00,  1.10it/s, episode=100, return=270.800]\n",
      "Iteration 2: 100%|████████████████████████████████████████| 50/50 [00:59<00:00,  1.19s/it, episode=150, return=498.300]\n",
      "Iteration 3: 100%|████████████████████████████████████████| 50/50 [00:41<00:00,  1.20it/s, episode=200, return=500.000]\n",
      "Iteration 4: 100%|████████████████████████████████████████| 50/50 [00:55<00:00,  1.11s/it, episode=250, return=418.000]\n",
      "Iteration 5: 100%|████████████████████████████████████████| 50/50 [00:59<00:00,  1.18s/it, episode=300, return=500.000]\n",
      "Iteration 6: 100%|████████████████████████████████████████| 50/50 [00:58<00:00,  1.18s/it, episode=350, return=500.000]\n",
      "Iteration 7: 100%|████████████████████████████████████████| 50/50 [00:59<00:00,  1.19s/it, episode=400, return=500.000]\n",
      "Iteration 8: 100%|████████████████████████████████████████| 50/50 [01:01<00:00,  1.22s/it, episode=450, return=500.000]\n",
      "Iteration 9: 100%|████████████████████████████████████████| 50/50 [00:47<00:00,  1.05it/s, episode=500, return=500.000]\n"
     ]
    }
   ],
   "source": [
    "actor_lr = 1e-3\n",
    "critic_lr = 1e-2\n",
    "num_episodes = 500\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "lmbda = 0.95\n",
    "epochs = 10\n",
    "eps = 0.2\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "_ = env.reset(seed=0)\n",
    "torch.manual_seed(0)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.n\n",
    "agent = PPO(state_dim, hidden_dim, action_dim, actor_lr, critic_lr, lmbda,\n",
    "            epochs, eps, gamma, device)\n",
    "\n",
    "return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)\n",
    "\n",
    "# Iteration 0: 100%|██████████| 50/50 [00:10<00:00,  4.81it/s, episode=50,\n",
    "# return=183.200]\n",
    "# Iteration 1: 100%|██████████| 50/50 [00:22<00:00,  2.24it/s, episode=100,\n",
    "# return=191.400]\n",
    "# Iteration 2: 100%|██████████| 50/50 [00:22<00:00,  2.24it/s, episode=150,\n",
    "# return=199.900]\n",
    "# Iteration 3: 100%|██████████| 50/50 [00:21<00:00,  2.33it/s, episode=200,\n",
    "# return=200.000]\n",
    "# Iteration 4: 100%|██████████| 50/50 [00:21<00:00,  2.29it/s, episode=250,\n",
    "# return=200.000]\n",
    "# Iteration 5: 100%|██████████| 50/50 [00:22<00:00,  2.22it/s, episode=300,\n",
    "# return=200.000]\n",
    "# Iteration 6: 100%|██████████| 50/50 [00:23<00:00,  2.14it/s, episode=350,\n",
    "# return=200.000]\n",
    "# Iteration 7: 100%|██████████| 50/50 [00:23<00:00,  2.16it/s, episode=400,\n",
    "# return=200.000]\n",
    "# Iteration 8: 100%|██████████| 50/50 [00:22<00:00,  2.23it/s, episode=450,\n",
    "# return=200.000]\n",
    "# Iteration 9: 100%|██████████| 50/50 [00:22<00:00,  2.25it/s, episode=500,\n",
    "# return=200.000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 573
    },
    "executionInfo": {
     "elapsed": 612,
     "status": "ok",
     "timestamp": 1649956030111,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "QDlFqdIM_TnW",
    "outputId": "673a3058-989e-4ce5-8dbd-31c1fe4bf830"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('PPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('PPO on {}'.format(env_name))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1649956030112,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "fgCdOpTq_TnW"
   },
   "outputs": [],
   "source": [
    "## continuous 智能体\n",
    "class PolicyNetContinuous(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(PolicyNetContinuous, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc_mu = torch.nn.Linear(hidden_dim, action_dim)  ## 用来求每个动作正态分布的均值\n",
    "        self.fc_std = torch.nn.Linear(hidden_dim, action_dim) ## 用来求每个动作正态分布的方差\n",
    "\n",
    "    ## 要求出摆动作的概率分布，默认是正态分布的\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        mu = 2.0 * torch.tanh(self.fc_mu(x))       ## predict每个动作的正态分布的均值，取值区间则是 [-2, 2]\n",
    "        std = F.softplus(self.fc_std(x))           ## predict每个动作的正态分布的方差，使用了函数 softplus\n",
    "        return mu, std  # 高斯分布的均值和标准差\n",
    "\n",
    "\n",
    "class PPOContinuous:\n",
    "    ''' 处理连续动作的PPO算法 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, actor_lr, critic_lr,\n",
    "                 lmbda, epochs, eps, gamma, device):\n",
    "        ## 状态的dimension，Pendulum-v1是 3 dim，也就是摆末端的(x,y)坐标，和角速度\n",
    "        ## https://gymnasium.farama.org/environments/classic_control/pendulum/\n",
    "        self.actor = PolicyNetContinuous(state_dim, hidden_dim,\n",
    "                                         action_dim).to(device)  ##  策略网络\n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device)##  价值网络\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(),\n",
    "                                                lr=actor_lr)  ## 策略网络配置优化器\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(),\n",
    "                                                 lr=critic_lr)  ## 价值网络配置优化器\n",
    "        self.gamma = gamma   ## 衰减因子的呢\n",
    "        self.lmbda = lmbda\n",
    "        self.epochs = epochs\n",
    "        self.eps = eps\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state): # 根据动作概率分布随机采样\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        mu, std = self.actor(state)      ## 拿到该状态下，均值和标准差\n",
    "        action_dist = torch.distributions.Normal(mu, std)    ##   配置 好采样的概率\n",
    "        action = action_dist.sample()       ## 对该状态下，所有的动作采样，采样的分布是高斯分布\n",
    "        return [action.item()]              ## 返回采样的动作值，也就是力矩的大小\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        ## 拿到这条序列内的 奖励、状态和动作，下一个状态、是否完成的\n",
    "        states = torch.tensor(transition_dict['states'],\n",
    "                              dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'],\n",
    "                                   dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'],\n",
    "                             dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        rewards = (rewards + 8.0) / 8.0  # 和TRPO一样,对奖励进行修改,方便训练\n",
    "        ## 用下个状态求下一个状态的状态动作价值，然后间接求出当前状态的状态动作价值\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 -\n",
    "                                                                       dones)\n",
    "        ## 间接求出的价值 - 直接求出的当前状态的状态动作价值，也就是 TD-error，或者是优势函数 A\n",
    "        td_delta = td_target - self.critic(states)\n",
    "        ##  算出优势函数值   广义优势估计，也就是平均值的\n",
    "        advantage = rl_utils.compute_advantage(self.gamma, self.lmbda,\n",
    "                                               td_delta.cpu()).to(self.device)\n",
    "        mu, std = self.actor(states)   ## 拿到 continuous 动作分布的均值和方差\n",
    "        ## 所有动作概率的分布，不反向传播求梯度，detach，给定正态分布的均值和方差，产生正态分布的\n",
    "        action_dists = torch.distributions.Normal(mu.detach(), std.detach())\n",
    "        # 动作是正态分布\n",
    "        old_log_probs = action_dists.log_prob(actions) ## 从产生的正态分布，给出每个动作的概率 log 值\n",
    "\n",
    "        for _ in range(self.epochs):\n",
    "            ## 拿到 continuous 动作分布的均值和方差\n",
    "            mu, std = self.actor(states)\n",
    "            ## 所有动作概率的分布，不反向传播求梯度，detach，给定正态分布的均值和方差，产生正态分布的\n",
    "            action_dists = torch.distributions.Normal(mu, std)\n",
    "            log_probs = action_dists.log_prob(actions)  ## 从产生的正态分布，给出每个动作的概率 log 值\n",
    "            ## 算重要性采样\n",
    "            ratio = torch.exp(log_probs - old_log_probs)\n",
    "            surr1 = ratio * advantage   ## 重要性采样和优势估计相乘的\n",
    "            surr2 = torch.clamp(ratio, 1 - self.eps, 1 + self.eps) * advantage  # 截断\n",
    "            ## 算出来的重要性采样，求出两者间的最小值，然后加负号，也就是最大化目标函数，不加负号的话是最小化目标函数\n",
    "            actor_loss = torch.mean(-torch.min(surr1, surr2))  # PPO损失函数\n",
    "            ## 直接求出当前状态的状态动作价值，和 间接求出的价值，使用 MSE 来算损失函数的，td_target不反向传播求梯度，detach\n",
    "            critic_loss = torch.mean(\n",
    "                F.mse_loss(self.critic(states), td_target.detach()))\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            self.critic_optimizer.zero_grad()   ## 价值网络的参数梯度置零的\n",
    "            actor_loss.backward()\n",
    "            critic_loss.backward()  ## 价值网络的损失loss反向传播梯度\n",
    "            self.actor_optimizer.step()\n",
    "            self.critic_optimizer.step()  # 更新价值函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 210368,
     "status": "ok",
     "timestamp": 1649956240475,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "zFwPi7ny_TnX",
    "outputId": "030c60e6-44ee-4901-f3c1-4f5946309869"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:  40%|███████████████                       | 79/200 [00:41<01:03,  1.92it/s, episode=70, return=-1214.618]\n",
      "\n",
      "KeyboardInterrupt\n",
      "\n"
     ]
    }
   ],
   "source": [
    "actor_lr = 1e-4\n",
    "critic_lr = 5e-3\n",
    "num_episodes = 2000\n",
    "hidden_dim = 128\n",
    "gamma = 0.9\n",
    "lmbda = 0.9\n",
    "epochs = 10\n",
    "eps = 0.2\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = 'Pendulum-v1'\n",
    "env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "_ = env.reset(seed=0)\n",
    "torch.manual_seed(0)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.shape[0]  # 连续动作空间\n",
    "agent = PPOContinuous(state_dim, hidden_dim, action_dim, actor_lr, critic_lr,\n",
    "                      lmbda, epochs, eps, gamma, device)\n",
    "\n",
    "return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)\n",
    "\n",
    "# Iteration 0: 100%|██████████| 200/200 [02:15<00:00,  1.47it/s, episode=200,\n",
    "# return=-984.137]\n",
    "# Iteration 1: 100%|██████████| 200/200 [02:17<00:00,  1.45it/s, episode=400,\n",
    "# return=-895.332]\n",
    "# Iteration 2: 100%|██████████| 200/200 [02:14<00:00,  1.48it/s, episode=600,\n",
    "# return=-518.916]\n",
    "# Iteration 3: 100%|██████████| 200/200 [02:19<00:00,  1.44it/s, episode=800,\n",
    "# return=-602.183]\n",
    "# Iteration 4: 100%|██████████| 200/200 [02:17<00:00,  1.45it/s, episode=1000,\n",
    "# return=-392.104]\n",
    "# Iteration 5: 100%|██████████| 200/200 [02:17<00:00,  1.45it/s, episode=1200,\n",
    "# return=-259.206]\n",
    "# Iteration 6: 100%|██████████| 200/200 [02:17<00:00,  1.45it/s, episode=1400,\n",
    "# return=-221.772]\n",
    "# Iteration 7: 100%|██████████| 200/200 [02:17<00:00,  1.45it/s, episode=1600,\n",
    "# return=-293.515]\n",
    "# Iteration 8: 100%|██████████| 200/200 [02:17<00:00,  1.45it/s, episode=1800,\n",
    "# return=-371.194]\n",
    "# Iteration 9: 100%|██████████| 200/200 [02:17<00:00,  1.45it/s, episode=2000,\n",
    "# return=-248.958]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 573
    },
    "executionInfo": {
     "elapsed": 1123,
     "status": "ok",
     "timestamp": 1649956241594,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "_lQ85nCC_TnY",
    "outputId": "39e0bfd7-e54e-4e0d-890a-bdf696a16534"
   },
   "outputs": [],
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('PPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 21)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('PPO on {}'.format(env_name))\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "第12章-PPO算法.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
